// 服务页面
const { getServiceItems, getServiceCategories, addFavorite, removeFavorite, getUserFavorites } = require('../../../api/serviceItems')
const { getCurrentUser } = require('../../../utils/auth')
const loadingManager = require('../../../utils/loadingManager')
const pageLoadingManager = require('../../../utils/pageLoadingManager')
const smartLoadingManager = require('../../../utils/smartLoadingManager')

Page({
  data: {
    // 全局加载状态
    globalLoading: false,
    globalSkeletonType: 'service',
    globalLoadingText: '服务事项加载中...',
    
    keywords: '',
    currentCateId: '',
    currentCateName: '',
    filterOptions: [
      { id: 'online', name: '仅在线办理' },
      { id: 'appoint', name: '仅可预约' }
    ],
    categories: [],
    items: [],
    cateCounts: {},
    filteredItems: [],
    cateMap: {},
    favorites: {},
    loading: false,
    loadingFavorites: false, // 添加收藏状态加载标志
    filter: { online: false, appoint: false },
    pagination: {
      page: 1,
      limit: 50,
      total: 0,
      totalPages: 0
    }
  },

  // 加载组件准备就绪
  onLoadingReady(e) {
    const loadingInstance = e.detail
    loadingManager.registerLoading('service', loadingInstance)
  },

  async onLoad() {
    // 显示页面加载效果
    smartLoadingManager.onPageEnter('pages/service/index/index')
    
    // 检查用户登录状态
    const currentUser = getCurrentUser()
    if (!currentUser) {
      // 用户未登录，跳转到登录页面
      wx.navigateTo({
        url: '/pages/auth/login/index'
      })
      return
    }
    
    // loadData 方法现在会自动加载默认分类的数据
    await this.loadData()
  },

  onReady() {
    // 页面准备完成，隐藏加载效果
    smartLoadingManager.onPageDataLoaded('pages/service/index/index')
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalSkeletonType: data.globalSkeletonType || 'service',
      globalLoadingText: data.globalLoadingText || '服务事项加载中...'
    })
  },

  async onShow() {
    // 检查用户登录状态
    const currentUser = getCurrentUser()
    if (!currentUser) {
      // 用户未登录，跳转到登录页面
      wx.navigateTo({
        url: '/pages/auth/login/index'
      })
      return
    }
    
    // 每次进入页面都重新加载数据，不使用缓存
    console.log('重新进入服务事项页面，重新加载数据')
    
    // 重置所有数据状态
    this.setData({
      categories: [],
      items: [],
      cateCounts: {},
      filteredItems: [],
      cateMap: {},
      favorites: {},
      keywords: '',
      filter: { online: false, appoint: false }
    })
    
    // loadData 方法现在会自动加载默认分类的数据
    await this.loadData()
  },

  // 加载收藏状态
  async loadFavoriteStatus() {
    // 防止重复调用
    if (this.data.loadingFavorites) {
      console.log('收藏状态正在加载中，跳过重复调用')
      return
    }

    try {
      const items = this.data.filteredItems
      if (items.length === 0) {
        console.log('没有服务事项，跳过收藏状态加载')
        return
      }

      // 获取当前用户
      const currentUser = getCurrentUser()
      if (!currentUser || !currentUser.userId) {
        console.log('用户未登录，跳过收藏状态加载')
        // 将所有项目标记为未收藏
        const favorites = {}
        items.forEach(item => {
          favorites[item.id] = false
        })
        this.setData({ favorites })
        return
      }

      // 设置加载状态
      this.setData({ loadingFavorites: true })
      console.log('开始加载收藏状态，用户ID:', currentUser.userId)
      
      // 获取用户收藏列表，使用服务端允许的最大limit值
      // 如果用户收藏数量超过100，可能需要分页获取，但这里先获取前100个
      const result = await getUserFavorites(currentUser.userId, { 
        limit: 100,
        status: 'active'
      })
      
      console.log('收藏列表API响应:', result)
      
      if (result.success && result.data && result.data.favorites) {
        // 创建收藏ID集合，便于快速查找
        const favoriteIds = new Set(result.data.favorites.map(fav => fav.serviceItemId))
        console.log('用户收藏的服务事项ID:', Array.from(favoriteIds))
        
        // 更新收藏状态
        const favorites = {}
        items.forEach(item => {
          favorites[item.id] = favoriteIds.has(item.id)
        })
        
        console.log('更新后的收藏状态:', favorites)
        this.setData({ favorites })
      } else {
        console.log('获取收藏列表失败或为空:', result)
        // 如果获取失败，将所有项目标记为未收藏
        const favorites = {}
        items.forEach(item => {
          favorites[item.id] = false
        })
        this.setData({ favorites })
      }
    } catch (error) {
      console.error('加载收藏状态失败:', error)
      // 出错时将所有项目标记为未收藏
      const favorites = {}
      this.data.filteredItems.forEach(item => {
        favorites[item.id] = false
      })
      this.setData({ favorites })
    } finally {
      // 清除加载状态
      this.setData({ loadingFavorites: false })
    }
  },

  // 加载数据
  async loadData() {
    try {
      this.setData({ loading: true })
      
      // 并行加载分类和服务事项数据
      const [categoriesRes, itemsRes] = await Promise.all([
        getServiceCategories({ include_stats: true }),
        getServiceItems({ limit: 100 }) // 获取所有服务事项
      ])

      console.log('分类API响应:', categoriesRes)
      console.log('服务事项API响应:', itemsRes)

      if (categoriesRes.success && itemsRes.success) {
        const categories = categoriesRes.data.categories
        const items = itemsRes.data.items
        
        console.log('分类数据:', categories)
        console.log('服务事项数据:', items)
        
        // 构建分类映射和计数
        const cateMap = {}
        const cateCounts = {}
        
        categories.forEach(cate => {
          cateMap[cate.id] = cate.name
          cateCounts[cate.id] = cate.activeItems || 0
        })

        console.log('分类映射:', cateMap)
        console.log('分类计数:', cateCounts)

        // 设置默认选中第一个分类
        const firstCateId = categories.length > 0 ? categories[0].id : ''

        this.setData({
          categories,
          items,
          cateMap,
          cateCounts,
          currentCateId: firstCateId
        })

        console.log('设置后的数据:', this.data.categories)
        console.log('分类数组长度:', this.data.categories.length)
        console.log('当前选中的分类ID:', this.data.currentCateId)

        this.updateCateName()
        
        // 进入页面时显示第一个分类的服务事项
        if (firstCateId) {
          await this.loadItemsByCategory(firstCateId)
        } else {
          // 如果没有分类，显示所有服务事项
          this.setData({ filteredItems: items })
          this.loadFavoriteStatus()
        }
        
        // 显示加载完成提示
        loadingManager.showSuccess('加载完成', 'service')
        
        // 通知智能加载管理器数据加载完成
        smartLoadingManager.onPageDataLoaded('pages/service/index/index')
      } else {
        console.error('数据加载失败:')
        console.error('分类响应:', categoriesRes)
        console.error('服务事项响应:', itemsRes)
        loadingManager.showError('数据加载失败', 'service')
        
        // 强制隐藏页面加载状态
        smartLoadingManager.forceHidePageLoading('pages/service/index/index')
      }
    } catch (error) {
      console.error('加载数据失败:', error)
      loadingManager.showError('网络错误，请重试', 'service')
      
      // 强制隐藏页面加载状态
      smartLoadingManager.forceHidePageLoading('pages/service/index/index')
    } finally {
      console.log('清除loading状态')
      this.setData({ loading: false })
    }
  },

  // 分类切换
  async onTapCate(e) {
    const id = e.currentTarget.dataset.id
    this.setData({ currentCateId: id, keywords: '' })
    this.updateCateName()
    await this.applyFilter()
    // applyFilter 会调用 loadItemsByCategory，该方法会自动加载收藏状态
  },

  updateCateName() {
    const cate = this.data.categories.find(c => c.id === this.data.currentCateId)
    this.setData({ currentCateName: cate ? cate.name : '' })
  },

  // 搜索
  async onSearchConfirm(e) {
    const keywords = (e.detail.value || '').trim()
    this.setData({ keywords })
    
    if (keywords) {
      await this.searchItems(keywords)
      // searchItems 方法会自动加载收藏状态
    } else {
      await this.applyFilter()
      // applyFilter 会调用 loadItemsByCategory，该方法会自动加载收藏状态
    }
  },

  // 搜索服务事项
  async searchItems(keywords) {
    try {
      this.setData({ loading: true })
      
      const params = {
        keywords,
        limit: 100
      }
      
      // 如果启用了筛选条件，添加到搜索参数中
      if (this.data.filter.online) {
        params.is_online = true
      }
      if (this.data.filter.appoint) {
        params.is_appointment = true
      }
      
      const res = await getServiceItems(params)
      
      if (res.success) {
        this.setData({
          filteredItems: res.data.items,
          currentCateName: '搜索结果'
        })
        
        // 加载收藏状态
        this.loadFavoriteStatus()
      } else {
        loadingManager.showError('搜索失败', 'service')
      }
    } catch (error) {
      console.error('搜索失败:', error)
      loadingManager.showError('搜索失败，请重试', 'service')
    } finally {
      this.setData({ loading: false })
    }
  },

  // 计算筛选结果
  async applyFilter() {
    const { currentCateId, keywords } = this.data
    const { online, appoint } = this.data.filter
    
    // 如果有搜索关键词，使用搜索功能
    if (keywords) {
      await this.searchItems(keywords)
      return
    }
    
    // 否则按分类筛选
    await this.loadItemsByCategory(currentCateId)
    // 注意：这里不调用loadFavoriteStatus，由调用方决定何时加载
  },

  // 按分类加载服务事项
  async loadItemsByCategory(categoryId) {
    try {
      this.setData({ loading: true })
      
      const params = {
        category_id: categoryId,
        limit: 100
      }
      
      // 如果启用了筛选条件，添加到参数中
      if (this.data.filter.online) {
        params.is_online = true
      }
      if (this.data.filter.appoint) {
        params.is_appointment = true
      }
      
      const res = await getServiceItems(params)
      
      if (res.success) {
        this.setData({
          filteredItems: res.data.items
        })
        
        // 加载收藏状态
        this.loadFavoriteStatus()
      } else {
        loadingManager.showError('加载失败', 'service')
      }
    } catch (error) {
      console.error('加载服务事项失败:', error)
      loadingManager.showError('加载失败，请重试', 'service')
    } finally {
      this.setData({ loading: false })
    }
  },

  // 进入事项详情/办理
  onTapItem(e) {
    const id = e.currentTarget.dataset.id
    const pageMap = {
      i1: '/pages/service/civil-affairs/apply/index',
      i2: '/pages/service/civil-affairs/relief/index',
      i5: '/pages/service/civil-affairs/pension-subsidy/index',
      i6: '/pages/service/urban-rural-construction/homestead-apply/index',
      i11: '/pages/service/agriculture-rural/machinery-subsidy/index',
      i13: '/pages/service/comprehensive-governance/dispute-mediation/index',
      i14: '/pages/service/comprehensive-governance/security-incident-report/index',
      i20: '/pages/service/certificate-services/resident-proof/index',
      i24: '/pages/service/public-services/streetlight-repair/index'
    }
    
    const target = pageMap[id]
    if (target) {
      wx.navigateTo({ url: target })
      return
    }
    
    const item = this.data.items.find(it => it.id === id)
    if (item && item.appoint && !item.online) {
      wx.showToast({ title: '该事项支持预约到村委办理', icon: 'none' })
    } else {
      wx.showToast({ title: '该服务的在线办理功能正在开发中', icon: 'none' })
    }
  },

  // 切换筛选
  async onToggleFilter(e) {
    const type = e.currentTarget.dataset.type
    const filter = { ...this.data.filter }
    filter[type] = !filter[type]
    this.setData({ filter })
    await this.applyFilter()
    // applyFilter 会调用相应的方法，这些方法会自动加载收藏状态
  },

  // 下拉刷新
  async onPullDownRefresh() {
    console.log('开始下拉刷新')
    try {
      // 重置搜索关键词和筛选条件
      this.setData({ 
        keywords: '',
        filter: { online: false, appoint: false }
      })
      
      // 重新加载所有数据
      await this.loadData()
      
      // 下拉刷新后显示当前分类的服务事项
      await this.showCurrentCategoryItems()
      
      // 显示刷新成功提示
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1500
      })
    } catch (error) {
      console.error('下拉刷新失败:', error)
      wx.showToast({
        title: '刷新失败，请重试',
        icon: 'none'
      })
    } finally {
      // 停止下拉刷新动画
      wx.stopPullDownRefresh()
    }
  },

  // 显示当前分类的服务事项
  async showCurrentCategoryItems() {
    try {
      this.setData({ loading: true })
      
      const currentCateId = this.data.currentCateId
      if (currentCateId) {
        // 显示当前分类的服务事项
        await this.loadItemsByCategory(currentCateId)
      } else {
        // 如果没有分类，显示所有服务事项
        const res = await getServiceItems({ limit: 100 })
        
        if (res.success) {
          this.setData({
            filteredItems: res.data.items,
            currentCateName: '所有服务事项'
          })
          
          // 加载收藏状态
          this.loadFavoriteStatus()
        } else {
          loadingManager.showError('加载失败', 'service')
        }
      }
    } catch (error) {
      console.error('显示当前分类服务事项失败:', error)
      loadingManager.showError('加载失败，请重试', 'service')
    } finally {
      this.setData({ loading: false })
    }
  },

  // 收藏/取消收藏
  async onToggleFav(e) {
    const id = e.currentTarget.dataset.id
    const isFavorited = this.data.favorites[id]
    
    // 获取当前用户
    const currentUser = getCurrentUser()
    console.log('当前用户信息:', currentUser)
    if (!currentUser || !currentUser.userId) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }
    
    try {
      wx.showLoading({ title: isFavorited ? '取消收藏中...' : '收藏中...' })
      
      let result
      if (isFavorited) {
        // 取消收藏
        result = await removeFavorite(id, currentUser.userId)
      } else {
        // 添加收藏
        result = await addFavorite(id, currentUser.userId)
      }
      
      if (result.success) {
        // 更新本地状态
        const favorites = { ...this.data.favorites }
        favorites[id] = !isFavorited
        this.setData({ favorites })
        
        wx.showToast({
          title: favorites[id] ? '已收藏' : '已取消收藏',
          icon: 'success',
          duration: 1500
        })
      } else {
        wx.showToast({
          title: result.message || (isFavorited ? '取消收藏失败' : '收藏失败'),
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('收藏操作失败:', error)
      wx.showToast({
        title: isFavorited ? '取消收藏失败' : '收藏失败',
        icon: 'none'
      })
    } finally {
      // 隐藏加载提示
      wx.hideLoading()
    }
  }
})
